import { staticUrl } from '../config';
import $url from '@/sheep/url/index.js';
const cdnUrl = (url = '', cdnurl = cdn) => {
  if (!url) return '';
  if (/^http/.test(url)) {
    return url;
  }
  return cdnurl + url;
};
/**
 * @description 格式化时间
 * @param {String|Number} dateTime 需要格式化的时间戳
 * @param {String} fmt 格式化规则 yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合 默认yyyy-mm-dd
 * @returns {string} 返回格式化后的字符串
 */
function timeFormat(dateTime = null, formatStr = 'yyyy-mm-dd') {
  let date;
  // 若传入时间为假值，则取当前时间
  if (!dateTime) {
    date = new Date();
  }
  // 若为unix秒时间戳，则转为毫秒时间戳（逻辑有点奇怪，但不敢改，以保证历史兼容）
  else if (/^\d{10}$/.test(dateTime?.toString().trim())) {
    date = new Date(dateTime * 1000);
  }
  // 若用户传入字符串格式时间戳，new Date无法解析，需做兼容
  else if (typeof dateTime === 'string' && /^\d+$/.test(dateTime.trim())) {
    date = new Date(Number(dateTime));
  }
  // 其他都认为符合 RFC 2822 规范
  else {
    // 处理平台性差异，在Safari/Webkit中，new Date仅支持/作为分割符的字符串时间
    date = new Date(typeof dateTime === 'string' ? dateTime.replace(/-/g, '/') : dateTime);
  }

  const timeSource = {
    y: date.getFullYear().toString(), // 年
    m: (date.getMonth() + 1).toString().padStart(2, '0'), // 月
    d: date.getDate().toString().padStart(2, '0'), // 日
    h: date.getHours().toString().padStart(2, '0'), // 时
    M: date.getMinutes().toString().padStart(2, '0'), // 分
    s: date.getSeconds().toString().padStart(2, '0'), // 秒
    // 有其他格式化字符需求可以继续添加，必须转化成字符串
  };

  for (const key in timeSource) {
    const [ret] = new RegExp(`${key}+`).exec(formatStr) || [];
    if (ret) {
      // 年可能只需展示两位
      const beginIndex = key === 'y' && ret.length === 2 ? 2 : 0;
      formatStr = formatStr.replace(ret, timeSource[key].slice(beginIndex));
    }
  }

  return formatStr;
}

/**
 * @description 时间戳转为多久之前
 * @param {String|Number} timestamp 时间戳
 * @param {String|Boolean} format
 * 格式化规则如果为时间格式字符串，超出一定时间范围，返回固定的时间格式；
 * 如果为布尔值false，无论什么时间，都返回多久以前的格式
 * @returns {string} 转化后的内容
 */
function timeFrom(timestamp = null, format = 'yyyy-mm-dd') {
  if (timestamp == null) timestamp = Number(new Date());
  timestamp = parseInt(timestamp);
  // 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
  if (timestamp.toString().length == 10) timestamp *= 1000;
  let timer = new Date().getTime() - timestamp;
  timer = parseInt(timer / 1000);
  // 如果小于5分钟,则返回"刚刚",其他以此类推
  let tips = '';
  switch (true) {
    case timer < 300:
      tips = '刚刚';
      break;
    case timer >= 300 && timer < 3600:
      tips = `${parseInt(timer / 60)}分钟前`;
      break;
    case timer >= 3600 && timer < 86400:
      tips = `${parseInt(timer / 3600)}小时前`;
      break;
    case timer >= 86400 && timer < 2592000:
      tips = `${parseInt(timer / 86400)}天前`;
      break;
    default:
      // 如果format为false，则无论什么时间戳，都显示xx之前
      if (format === false) {
        if (timer >= 2592000 && timer < 365 * 86400) {
          tips = `${parseInt(timer / (86400 * 30))}个月前`;
        } else {
          tips = `${parseInt(timer / (86400 * 365))}年前`;
        }
      } else {
        tips = timeFormat(timestamp, format);
      }
  }
  return tips;
}

/**
 * 格式化字符数
 * @param {string} num - 需要格式化的数字
 * @returns {string} - 格式化后的数字
 */
function formatCharCount(num) {
  if (!Number(num)) return num; // 如果输入的不是数字则返回原数字
  if (num >= 1e3 && num < 1e4) {
    num = (num / 1e3).toFixed(1) + 'k'; // 如果数字在1000到10000之间，则转换为千位分隔符并添加"k"后缀
  } else if (num >= 1e4 && num < 1e7) {
    num = (num / 1e4).toFixed(1) + 'w'; // 如果数字在10000到100000之间，则转换为万位分隔符并添加"w"后缀
  } else if (num >= 1e7) {
    num = (num / 1e7).toFixed(1) + 'kw'; // 如果数字在100000以上，则转换为十万位分隔符并添加"kw"后缀
  }
  return num; // 返回格式化后的数字
}

export function formatFile(res) {
  if (Array.isArray(res.tempFiles)) {
    return res.tempFiles.map((item) => ({
      // #ifdef MP-WEIXIN
      url: item.tempFilePath,
      type: item.fileType,
      // #endif

      size: item.size,

      // #ifndef MP-WEIXIN
      type: item.type,
      url: item.path,
      // #endif
    }));
  } else {
    return [
      {
        url: res.tempFilePath,
        type: res.tempFile.type,
        size: res.tempFile.size,
      },
    ];
  }
}

/** 选择媒体
 * @param {Array/String} type 媒体类型 ['image','video'] / 'image,video'
 * @param {Array/String} num  媒体数量 1~9
 * @param {Array/String} source 媒体选择方式 ['album','camera'] / 'album,camera'
 * 	
 */
function chooseFile(type='',num=1,source  = '') {
	
	let mediaType = normalizeParam(type, ['image', 'video'], 'type')
	let sourceType = normalizeParam(source, ['album', 'camera'], 'source')
	
	// #ifdef H5 || APP-PLUS
	let btns
	if (!type) btns = ['图片', '视频']
	// #endif
	
	if (mediaType === false || sourceType === false) {
		return Promise.resolve(false)
	}
	return new Promise( async (resolve, reject) => {
		// #ifdef MP-WEIXIN ||  APP-PLUS
		// 只有微信小程序才支持chooseMedia接口
		uni.chooseMedia({
			mediaType,
			sourceType,
			count: num,
			maxDuration: 30,
			success: (Media) => resolve(formatFile(Media)),
			fail: (err) => {
				errCB(err)
				resolve(false)
			}
		});
		// #endif

		// #ifdef H5
		if(mediaType.length==1){
			let file = await chooseMedia(mediaType[0],num,sourceType)
			resolve(file)
		}else if(mediaType.length==2){
			uni.showActionSheet({
				itemList: btns,
				success:async (res) => {
					let file = await chooseMedia(mediaType[res.tapIndex],num,sourceType)
					resolve(file)
				},
				fail: (err) =>{
					errCB(err)
					resolve(false)
				}
			});
		}
		// #endif
	});
}
function chooseMedia(type,num=1,sourceType){
	return new Promise((resolve, reject)=>{
		if (type == 'image') {
			uni.chooseImage({
				count: num,
				sourceType,
				sizeType: ['original'],
				success: async (img) => resolve(formatFile(img)),
				fail: (err) => {
					errCB(err)
					resolve(false)
				},
			});
		} else if (type == 'video') {
			uni.chooseVideo({
				sourceType,
				maxDuration: 60,
				success: async(video) => resolve(formatFile(video)),
				fail: (err) =>  {
					errCB(err)
					resolve(false)
				}
			});
		}
	})
}
function normalizeParam(param, defaultVal, name) {
	if (!param) return defaultVal

	if (typeof param === 'string') {
		return param.split(',')
	} else if (Array.isArray(param)) {
		return param
	} else {
		console.log(`${name} 参数错误`)
		return false
	}
}
function errCB(data){
	console.log('data',data)
	uni.showToast({
		icon:'none',
		title:JSON.stringify(data).includes('cancel') ? '操作取消':'请检查是否授权'
	}) 
}
/** 下载文件
 * @param {Object} urls [ "url.mp4" ] 或者 "url1.mp4,url1.mp4"
 */
export function downloadFiles(urls){
	if(!urls)return Promise.reject(false)
	let downList = []
	if(urls instanceof String){
		downList = urls.split(',')
	}else{
		downList = urls
	}
	return new Promise( async (resolve, reject)=>{
		// #ifdef MP
			wx.getSetting({
			  success: async (res)=>{
				if (!res.authSetting['scope.writePhotosAlbum']) {
				  wx.authorize({
					scope: 'scope.writePhotosAlbum',
					success:async ()=>{
						 let res = await Promise.allSettled(downList.map(url=>downloadFile(url)))
						 resolve(res)
					},
					fail: () => {
						uni.showToast({
							icon:'none',
							title:'未授权储存权限,请点击右上角进入设置，允许保存到相册',
							duration:3000
						});
						return reject(false)
					}
				  })
				}else{
					let res = await Promise.allSettled(downList.map(url=>downloadFile(url)))
					resolve(res)
				}
			  }
			})
		// #endif
		// #ifndef MP
			let res = await Promise.allSettled(downList.map(url=>downloadFile(url)))
			resolve(res)
		// #endif
	})
}
function downloadFile(url){
	return new Promise( (resolve, reject)=>{
		uni.downloadFile({
			url: $url.cdn(url), 
			success: async (data) => {
				if (data.statusCode === 200) {
					// #ifdef APP || MP
					var res = await saveMediaToPhotosAlbum(data)
					if(res){
						resolve(res)
					}else{
						reject(false)
					}
					// #endif
					// #ifdef H5
					uni.showToast({
						title:'H5不支持此方法',
						icon:'none'
					})
					reject(false)
					// #endif
				}
			},
			fail: (err) => {
				reject(false)
			}
		});
	})
}
function saveMediaToPhotosAlbum(data){
	return new Promise((resolve, reject)=>{
		uni[data.header['Content-Type']=='video/mp4' ? 
			'saveVideoToPhotosAlbum':'saveImageToPhotosAlbum']({
			filePath: data.tempFilePath,
			success: (res)=>{
				resolve(res)
			},
			fail: (err) => {
				reject(false)
			}
		});	
	})
}

export { chooseFile, formatCharCount, timeFormat, timeFrom, cdnUrl };
